#include "acciones.h"
#include "utilMenu.h"
#include "rtc.h"

#include "DHT.h"

#ifdef __PC__
  #include "commonArduino.h"
#endif

#define TIMEOUT_CALEFACCION (5L*1000) // msec
#define MAX_TEMPERATURA     40		  // ºC


#define PIN_INVERSOR    30
#define PIN_CALEFACCION  0
#define PIN_LUCES        0
#define PIN_PUERTAS      0
#define PIN_LDR	      0
/*
 *   int PinCierraPuertas = 38;	// Pin sw puertas
  int PinAbrePuertas = 39;		// Pin sw puertas
  //int PinContacto = 40;	// Pin +12 bajo contacto
  //int PinRelePosicion = 33;	// No hace falta, se enciende posición y cruce a la vez
  int PinCruce = 34;
  int PinNiebla	= 35;
 // int Rx3 = 14;
  //int Tx3 = 15;
  #define DHTPIN 44     // what pin we're connected to. Se define como una constante que reemplazará los valores.
  #define PinCentralita 42
  #define PinShunt 12		// Referencia Shunt batería
  #define PinPlafon 45		// +12v del plafon
  #define PinPosicion 37	// Ref. Posición
  #define PinPrueba 48		// prueba de sensing 12v with arduino
 *
 * */


bool inversorEncendido  = false;
tEstadoLuces estadoLuces = OFF;
bool estadoPuertas      = false;
bool estadoLDR          = false;



void conmutarInversor()
{
	inversorEncendido = !inversorEncendido;
	if( inversorEncendido) {
		digitalWrite( PIN_INVERSOR, HIGH);
	}
	else {
		digitalWrite( PIN_INVERSOR, LOW);
	}
}



void conmutarLuces()
{
	if( estadoLuces == OFF) {
		estadoLuces = AUTO;
	}
	else if( estadoLuces == AUTO) {
		estadoLuces = ON;
	}
	else {
		estadoLuces = OFF;
	}
	// La activación AUTO habrá que hacerla en la función 'loop'
	//  para contar con unos retardos que prevengan posible glitchs del sensor luminoso.
}
void conmutarPuertas()
{
	if( estadoPuertas) {
		digitalWrite( PIN_PUERTAS, LOW);
		estadoPuertas = false;
	}
	else {
		digitalWrite( PIN_PUERTAS, HIGH);
		estadoPuertas = true;
	}
}

void conmutarLDR()
{
	estadoLDR = !estadoLDR;
	if( estadoLDR) {
		digitalWrite( PIN_LDR, HIGH);
	}
	else {
		digitalWrite( PIN_LDR, LOW);
	}
}


// ******************************************************************
// ***	CALEFACCION
// ***
int  opcionCalefaccion    = DESACTIVADA;
bool calefaccionEncendida = false;
long calefaccionStartTime, calefaccionStopTime;
long currentTime = 0;

void comprobarCalefaccion()
{
	calefaccionEncendida = (opcionCalefaccion == ACTIVADA) ||
			( (opcionCalefaccion == PROGRAMADA) && (currentTime > calefaccionStartTime) && (currentTime < calefaccionStopTime));
	if( calefaccionEncendida) {
		digitalWrite( PIN_CALEFACCION, HIGH);
	}
	else {
		digitalWrite( PIN_CALEFACCION, LOW);
	}
}
void conmutarCalefaccion()
{
	if( calefaccionEncendida) {
		opcionCalefaccion = ACTIVADA;
	}
	else {
		opcionCalefaccion = DESACTIVADA;
	}
	comprobarCalefaccion();
}
void encenderCalefaccion()
{
	opcionCalefaccion = ACTIVADA;
//	comprobarCalefaccion();
}
void apagarCalefaccion()
{
	opcionCalefaccion = DESACTIVADA;
//	comprobarCalefaccion();
}





tProgramaCalefaccion programaCalefaccion;

bool programarCalefaccion( const char *buffer)
{
	char currentIndex = getCurrentIndex();

	int temp = (getFirstDigit() - '0') * 10  + getNextDigit() - '0';
	programaCalefaccion.temperatura = temp;
	if( temp > 35) {
		setCurrentIndex( currentIndex);
	    //printf("currentIndex=%d\n", currentIndex);
		return false;
	}

	int hora = (getNextDigit() - '0') * 10  + getNextDigit() - '0';
	int min  = (getNextDigit() - '0') * 10  + getNextDigit() - '0';
	programaCalefaccion.inicio = hora * 60 + min;
	if( (hora >= 24 ) || (min >= 60)) {
		setCurrentIndex( currentIndex);
		return false;
	}

	hora = (getNextDigit() - '0') * 10  + getNextDigit() - '0';
	min  = (getNextDigit() - '0') * 10  + getNextDigit() - '0';
	programaCalefaccion.fin = hora * 60 + min;
	if( (hora >= 24 ) || (min >= 60)) {
		setCurrentIndex( currentIndex);
		return false;
	}
	setCurrentIndex( currentIndex);
	return true;
}


bool programarCalefaccion2( const char *buffer)
{
	char currentIndex = getCurrentIndex();
/*
	int temp = (getFirstDigit() - '0') * 10  + getNextDigit() - '0';
	programaCalefaccion2.temperatura = temp;
	if( temp > 35) {
		setCurrentIndex( currentIndex);
	    //printf("currentIndex=%d\n", currentIndex);
		return false;
	}
*/
	int hora = (getFirstDigit() - '0') * 10  + getNextDigit() - '0';
	int min  = (getNextDigit() - '0') * 10  + getNextDigit() - '0';
	programaCalefaccion.inicio = hora * 60 + min;
	if( (hora >= 24 ) || (min >= 60)) {
		setCurrentIndex( currentIndex);
		return false;
	}

	hora = (getNextDigit() - '0') * 10  + getNextDigit() - '0';
	min  = (getNextDigit() - '0') * 10  + getNextDigit() - '0';
	programaCalefaccion.fin = hora * 60 + min;
	if( (hora >= 24 ) || (min >= 60)) {
		setCurrentIndex( currentIndex);
		return false;
	}
	setCurrentIndex( currentIndex);
	return true;
}

bool setTemperaturaCalefaccion( const char *buffer)
{
	char currentIndex = getCurrentIndex();

	int temp = (getFirstDigit() - '0') * 10  + getNextDigit() - '0';
	programaCalefaccion.temperatura = temp;
	if( temp > MAX_TEMPERATURA) {
		setCurrentIndex( currentIndex);
	    //printf("currentIndex=%d\n", currentIndex);
		return false;
	}

	setCurrentIndex( currentIndex);
	return true;
}

int readTemperature()
{
	// Reading temperature or humidity takes about 250 milliseconds!
	// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
	float t = dht.readTemperature();

	// check if returns are valid, if they are NaN (not a number) then something went wrong!
	if( isnan( t)) {
		Serial.println( "Failed to read from DHT");
		return 90;
	}
	return t;
}


unsigned timestampEstadoCalefaccion = 0;

void actualizarEstadoCalefaccion()
{
	unsigned long timeSinceLastUpdate = (unsigned long)millis() - timestampEstadoCalefaccion;
//    printf("timeSinceLastUpdate=%lu\n", timeSinceLastUpdate);
	if( timeSinceLastUpdate < TIMEOUT_CALEFACCION) {
		return;
	}
	timestampEstadoCalefaccion = millis();

	switch( opcionCalefaccion)
	{
	  case DESACTIVADA:
		  calefaccionEncendida = false;
		  break;
	  case ACTIVADA:
		  calefaccionEncendida = true;
		  break;
	  case PROGRAMADA:
		  char* hhmm = getTimeHHMM();
		  //printf("hhmm=%4.4s\n", hhmm);
		  int minutes = ((hhmm[0] - '0') * 10 + hhmm[1] - '0') * 60;
		  //printf("minutes=%d\n", minutes);
		  minutes += ((hhmm[2] - '0') * 10) + hhmm[3] - '0';
		  //printf("minutes=%d\n", minutes);
		  //printf("programaCalefaccion.inicio=%d\n", programaCalefaccion.inicio);
		  //printf("programaCalefaccion.fin=%d\n", programaCalefaccion.fin);
		  bool encender =
				  (programaCalefaccion.inicio < programaCalefaccion.fin) &&
				  (programaCalefaccion.inicio <= minutes) &&
				  (minutes <= programaCalefaccion.fin);
		  //printf("encender1=%d\n", encender);
		  encender = encender ||
				  (programaCalefaccion.inicio > programaCalefaccion.fin) &&
				  ( (programaCalefaccion.inicio <= minutes) ||
				    (minutes <= programaCalefaccion.fin) );
		  //printf("encender2=%d\n", encender);
		  if( encender) {
			  calefaccionEncendida = true;
		  }
		  else {
			  calefaccionEncendida = false;
		  }
		  break;
	}
	if( calefaccionEncendida) {
		bool temperaturaBaja = (readTemperature() < programaCalefaccion.temperatura);
		//printf("temperaturaBaja=%d\n", temperaturaBaja);
		if( temperaturaBaja) {
			digitalWrite( PIN_CALEFACCION, HIGH);
		}
		else {
			digitalWrite( PIN_CALEFACCION, LOW);
		}
	}
	else {
		digitalWrite( PIN_CALEFACCION, LOW);
	}
}
